How come you could implement this so easily, while nodejs/node#13209 is still open? Some kind of backwards compatibility thing? What am I missing?

Interesting... it seems a lot in that thread is to do with ambiguity with await as a variable (which isn't something CS needs to deal with as await is always parsed as an 'operator') as well as confusion between REPL support and supporting top-level await (which is a whole other thang). Perhaps it is easy in this case because we're using a custom evaluator, whereas the default evaluator just uses eval? I'm not sure how the internals work 😞

One thing I didn't think about that came up in the thread is what should happen if the user ctrl+c's an awaiting promise. The way this is implemented right now, if the promise hangs forever there is no observable issue (same as doing new Promise -> in the REPL), however if the promise eventually resolves (e.g. await new Promise (r) -> setTimeout r, 5000) then the REPL will eventually log the result (in this case undefined), even after ctrl+c is pressed.

That said, with some acrobatics it should be possible to intercept the SIGINT and prevent the REPL handler from being called to print the result (which won't prevent the computation from running of course, which is the nature of async in JS).

@AlvaroBernalG do you want to have a play with this branch and see if it works as you'd hoped?

@connec I have been playing with your branch and the only thing that I found is that I am unable to assign the result of an await to a variable. Which useful in cases when you want to comfortably inspect the element returned.

@princejwesley has a gist where he solve a similar problem by appending the assignment variable to
the global object.

So if you have an await whose result is being assigned to a variable like so:

coffee>myVariableResult = await wiki().page('batman')

It would get transpiled into:

// `(async() => global.${myVariableResult}=${awaitExpression})()`

(async() => global.myVariableResult = await wiki().page('batman'))()

if there is no variable assignment then:

// `(async() => ${awaitExpression})()`

(async() => await wiki().page('batman'))()

@AlvaroBernalG Good example. That's certainly unexpected behavior.

Good catch indeed, didn't think about assignment. I suppose I need to update the isAwait condition to also accept Assign's whose value is an Await.

Just to be clear, the second example ("if there is no variable assignment") is working as expected?

@connec I confirm that besides that everything is working as expected ( Even canceling the promise before it finish with ctrl +c .. which is awesome :) )

I found a much more robust approach that also supports await inside arbitrary expressions, e.g.

console.log await Promise.resolve 1

# and assignment, of course :)
foo = await Promise.resolve 1

About the cancelling... that's actually a bit weird, and I don't think there's anything we can easily do about it. For example, running the following in the REPL will result in foo being set to the 'cancelled' value (1).

foo = await new Promise (resolve) -> setTimeout (-> resolve 1), 5000
# ^C
foo = 2
# wait a few seconds...
_
# undefined
foo
# 1

This is because it's impossible to actually cancel a native promise.

That said, in its current form it's useful for playing with promise libraries, and the same problem would exist in manual usage:

foo = null
(new Promise (resolve) -> setTimeout (-> resolve 1), 5000).then (result) -> foo = result
foo = 2
# wait a few seconds
foo
# 1

Let me know if this works better for you @AlvaroBernalG 😄

@AlvaroBernalG can you please confirm that this PR works as expected?

@lydell, any notes or is this ready to merge?

I haven't tested it, but the code looks good.

@connec @GeoffreyBooth Apologies for the delay. For some reason I missed the emails and warnings on Github.

I tested the branch and I can confirm that it is working as expected.

@connec Thank you very much. Coffeescript REPL is now my default REPL.

Once again apologies for the delay.

Great, thanks!

Glad it's working out for you @AlvaroBernalG 😄